package com.itheima.wisdomnext.service.ImpI;

import com.itheima.wisdomnext.entity.*;
import com.itheima.wisdomnext.entity.Result.ResponseResult;
import com.itheima.wisdomnext.entity.Result.enumcalss.ErrorCode;
import com.itheima.wisdomnext.mapper.*;
import com.itheima.wisdomnext.service.*;
import com.itheima.wisdomnext.util.PostS_Util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

@Service
public class PostServiceImpl implements PostService {

    @Autowired
    private PostMapper postMapper; // 依赖的 PostMapper

    @Autowired
    private LikeMapper likeMapper; // 依赖的 PostMapper

    @Autowired
    private QaPostMapper qaPostMapper; // 依赖的 PostMapper

    @Autowired
    private QaAnswerOptionMapper qaAnswerOptionMapper ; // 依赖的 PostMapper

    @Autowired
    private PostImageMapper postImageMapper; // 依赖的 PostMapper

    @Autowired
    private UserService userService; // 自动注入 userMapper

    @Autowired
    private FavoriteService favoriteService; // 自动注入 PostService

    @Autowired
    private FollowService followService; // 自动注入 PostService

    @Autowired
    private FileService fileService; // 注入 FileService 处理文件

    /**
     * 创建一个帖子，包括普通帖和问答帖（根据类型）
     *
     * @param post 帖子信息
     * @param files 上传的文件数组
     * @param type 帖子类型（如：问答帖类型）
     * @param title 问答帖的标题
     * @param nestedArray 问答帖的选项数组（仅在类型为 "choice" 时使用）
     * @return 返回创建的帖子对象
     */
    public Post createPost(Post post, MultipartFile[] files, String type, String title, String[] nestedArray) {
        // **1. 先保存帖子到数据库**
        postMapper.insertPost(post);  // 将帖子数据插入到数据库的 post 表中
        Integer postId = post.getId();  // 获取生成的帖子 ID

        // **2. 处理文件上传**
        if (files != null && files.length > 0) {
            List<String> imageUrls = new ArrayList<>();  // 用于存储图片文件的 URL
            String videoUrl = null;  // 用于存储视频文件的 URL

            // **遍历上传的文件**
            for (MultipartFile file : files) {
                String fileExtension = getFileExtension(file.getOriginalFilename());  // 获取文件扩展名

                // **处理视频文件（mp4 或 avi 格式）**
                if (fileExtension.equals("mp4") || fileExtension.equals("avi")) {
                    videoUrl = fileService.saveFile(file, "video");  // 保存视频文件并获取视频 URL
                }
                // **处理图片文件（jpg、png、jpeg 格式）**
                else if (fileExtension.equals("jpg") || fileExtension.equals("png") || fileExtension.equals("jpeg")) {
                    imageUrls.add(fileService.saveFile(file, "image"));  // 保存图片文件并获取图片 URL
                }
            }

            // **更新帖子的视频 URL**
            post.setVideoUrl(videoUrl);  // 将视频 URL 设置到帖子对象中

            // **保存图片路径到 post_images 表**
            for (String imageUrl : imageUrls) {
                int lastIndex = imageUrl.lastIndexOf("\\");  // 获取文件路径中的最后一个反斜杠索引
                int secondLastIndex = imageUrl.lastIndexOf("\\", lastIndex - 1);  // 获取倒数第二个反斜杠索引
                String relativePath = imageUrl.substring(secondLastIndex + 1);  // 提取相对路径
                postImageMapper.insertPostImage(postId, relativePath);  // 将图片路径插入到 post_images 表中
            }
        } else {
            PostS_Util.isTrue(true, ErrorCode.FAILED,"没有文件上传");
        }

        // **3. 如果是问答帖子，创建 qa_post**
        Integer questionPostId = null;  // 用于存储问答帖的 ID
        if (type == null && title == null) {
            // 如果类型和标题为空
            PostS_Util.isTrue(true,ErrorCode.FAILED,"类型和标题为空");
        }
            QaPost qaPost = new QaPost();  // 创建一个新的 QaPost 对象
            qaPost.setQuestionUserId(post.getUserid());  // 设置问答帖的提问用户 ID
            qaPost.setQuestionTitle(title);  // 设置问答帖的标题
            qaPost.setQuestionType(type);  // 设置问答帖的类型
            qaPost.setCategoryId(post.getCategoryId());  // 设置问答帖的分类 ID

            // **存入问答帖子**
            qaPostMapper.insertQaPost(qaPost);  // 将问答帖插入到数据库的 qa_post 表中
            questionPostId = qaPost.getId();  // 获取问答帖的 ID

            // **4. 更新 posts 表，把 question_post_id 关联到问答帖子**
            postMapper.updateQuestionPostId(postId, questionPostId);  // 更新 posts 表中的 question_post_id 字段，将其与问答帖关联

            // **5. 处理选项**
            if ("choice".equals(type)) {  // 如果是选择题类型
                for (String option : nestedArray) {  // 遍历选项数组
                    QaAnswerOption optionEntity = new QaAnswerOption();  // 创建一个新的 QaAnswerOption 实体对象
                    optionEntity.setQuestionId(questionPostId);  // 设置选项的问答帖 ID
                    optionEntity.setOptionText(option.trim());  // 设置选项文本
                    qaAnswerOptionMapper.insertOption(optionEntity);  // 将选项插入到数据库的 qa_answer_option 表中
                }
            }

        return post;  // 返回创建的帖子对象
    }

    /**
     * 获取文件的扩展名（不包含点号）
     *
     * @param fileName 文件名
     * @return 返回文件扩展名，全部转换为小写
     */
    private String getFileExtension(String fileName) {
        // 获取文件扩展名：从最后一个点号的位置开始截取，去掉点号后面的部分
        return fileName.substring(fileName.lastIndexOf('.') + 1).toLowerCase();
    }

    /**
     * 根据用户 ID 获取该用户的所有帖子（包括普通帖和问答帖）
     *
     * @param id 用户 ID
     * @return 帖子列表封装成 Postshow 的统一响应结果
     */
    public ResponseResult<List<Postshow>> getPostById(int id) {
        List<Post> posts = postMapper.getPostById(id);

        if (posts == null && posts.isEmpty()) {
            PostS_Util.isTrue(true,ErrorCode.FAILED,"查询失败");
        }
            List<Postshow> postshows = new ArrayList<>();

            for (Post post : posts) {
                Postshow postshow = new Postshow();
                postshow.setId(post.getId());

                List<Users> usertest = userService.getUserByIdPost(post.getUserid());
                postshow.setUsers(usertest);
                postshow.setTitle(post.getTitle());
                postshow.setContent(post.getContent());
                postshow.setCategoryId(post.getCategoryId());
                postshow.setVisibility(post.getVisibility());
                postshow.setViews(post.getViews());
                postshow.setLikes(post.getLikes());
                postshow.setCreatedAt(post.getCreatedAt());
                postshow.setBanned(post.getBanned());
                postshow.setApproved(post.getApproved());
                postshow.setVideoUrl(post.getVideoUrl());
                postshow.setCommentPostId(post.getCommentPostId());
                postshow.setLocation(post.getLocation());
                postshow.setQuestionPostId(post.getQuestionPostId());

                // 图片
                List<String> images = postMapper.getImagesByPostId(post.getId());
                postshow.setImages(images);

                // 问答帖子处理
                if (post.getQuestionPostId() != null) {
                    QaPost qaPost = getQaPostById(Long.valueOf(post.getQuestionPostId()));
                    if (qaPost != null && "choice".equals(qaPost.getQuestionType())) {
                        List<QaAnswerOption> options = getOptionsByQuestionId(qaPost.getId());
                        qaPost.setAnswerOptions(options);
                    }
                    postshow.setQaPost(qaPost);
                }

                postshows.add(postshow);
            }

            return ResponseResult.success("查询成功", postshows);
    }

    /**
     * 获取单个帖子的详细信息。
     *
     * 包括作者信息、图片、问答内容、以及当前用户是否点赞、收藏、关注等状态。
     *
     * @param pid 帖子 ID（必填）
     * @param userId 当前登录用户 ID（可选，用于判断是否点赞、收藏、关注等状态）
     * @return 包含完整详情的 Postshow 对象封装的统一响应结果
     */
    public ResponseResult<Postshow> getPostShowBypId(int pid, Long userId) {
        Post post = postMapper.getPostBypId(pid);

        if (post == null) {
            PostS_Util.isTrue(true,ErrorCode.FAILED,"没查询到帖子");
        }

        Postshow postshow = new Postshow();
        postshow.setId(post.getId());
        List<Users> usertest = userService.getUserByIdPost(post.getUserid());
        postshow.setUsers(usertest);
        postshow.setTitle(post.getTitle());
        postshow.setContent(post.getContent());
        postshow.setCategoryId(post.getCategoryId());
        postshow.setViews(post.getViews());
        postshow.setLikes(post.getLikes());
        postshow.setCreatedAt(post.getCreatedAt());
        postshow.setBanned(post.getBanned());
        postshow.setApproved(post.getApproved());
        postshow.setVideoUrl(post.getVideoUrl());
        postshow.setCommentPostId(post.getCommentPostId());
        postshow.setLocation(post.getLocation());
        postshow.setQuestionPostId(post.getQuestionPostId());

        // 图片
        List<String> images = postMapper.getImagesByPostId(post.getId());
        postshow.setImages(images);

        // 问答帖子
        if (post.getQuestionPostId() != null) {
            QaPost qaPost = getQaPostById(Long.valueOf(post.getQuestionPostId()));
            if (qaPost != null && "choice".equals(qaPost.getQuestionType())) {
                List<QaAnswerOption> options = getOptionsByQuestionId(qaPost.getId());
                qaPost.setAnswerOptions(options);
            }
            postshow.setQaPost(qaPost);
        }

        // 当前用户相关信息（是否点赞、收藏、关注）
        if (userId != null) {
            int uid = Math.toIntExact(userId);

            boolean likedByUser = isPostLikedByUser(post.getId(), uid);
            postshow.setLikedByUser(likedByUser);

            boolean favoritedByUser = favoriteService.isPostFavorited(uid, post.getId()) > 0;
            postshow.setFavoritedByUser(favoritedByUser);

            boolean followedByUser = followService.isUserFollowing(uid, post.getUserid());
            postshow.setFollowedByUser(followedByUser);
        }

        return ResponseResult.success("查询成功", postshow);
    }

    /**
     * 获取指定用户可见的帖子列表
     *
     * 该方法会判断每个帖子是否符合用户的可见性规则，并将其转换为 `Postshow` 对象，返回该列表。
     *
     * @param userId 用户 ID（如果为 null，则返回所有可见的帖子）
     * @return 返回符合用户可见性规则的帖子列表
     */
    public List<Postshow> getVisiblePostsForUser(Long userId) {
        // 获取所有帖子
        List<Post> posts = postMapper.getAllPosts();

        // 如果没有帖子，返回空列表
        if (posts == null || posts.isEmpty()) return Collections.emptyList();

        List<Postshow> postshows = new ArrayList<>();

        // 遍历每个帖子，判断该用户是否可见
        for (Post post : posts) {
            // 如果传入了用户 ID，则判断该用户是否有权限查看该帖子
            if (userId != null) {
                String visibility = post.getVisibility(); // 获取帖子可见性设置
                Long authorId = Long.valueOf(post.getUserid()); // 获取帖子作者 ID

                // 判断是否是该用户自己
                boolean isSelf = userId.equals(authorId);

                // 判断用户是否是该帖子的粉丝或关注者
                boolean isFan = followService.isUserFollowing(authorId.intValue(), userId.intValue());
                boolean isFollowing = followService.isUserFollowing(userId.intValue(), authorId.intValue());

                // 根据帖子可见性规则判断用户是否可以查看该帖子
                boolean canView = "public".equals(visibility)  // 公开的帖子，任何人都可以看
                        || ("friends".equals(visibility) && isFan)  // 粉丝可见，必须是该帖子的粉丝
                        || ("followed".equals(visibility) && isFollowing)  // 关注的可见，必须关注该作者
                        || ("private".equals(visibility) && isSelf);  // 仅自己可见，必须是作者自己

                // 如果不符合查看条件，则跳过该帖子
                if (!canView) continue;
            }

            // 创建一个 Postshow 对象，用来存储处理后的帖子信息
            Postshow postshow = new Postshow();
            // 通用字段赋值
            postshow.setId(post.getId());
            postshow.setUsers(userService.getUserByIdPost(post.getUserid())); // 获取作者信息
            postshow.setTitle(post.getTitle());
            postshow.setContent(post.getContent());
            postshow.setCategoryId(post.getCategoryId());
            postshow.setVisibility(post.getVisibility());
            postshow.setViews(post.getViews());
            postshow.setLikes(post.getLikes());
            postshow.setCreatedAt(post.getCreatedAt());
            postshow.setBanned(post.getBanned());
            postshow.setApproved(post.getApproved());
            postshow.setVideoUrl(post.getVideoUrl());
            postshow.setCommentPostId(post.getCommentPostId());
            postshow.setLocation(post.getLocation());
            postshow.setQuestionPostId(post.getQuestionPostId());

            // 设置该帖子的所有图片
            postshow.setImages(postMapper.getImagesByPostId(post.getId()));

            // 如果是问答帖子，处理问答相关数据
            if (post.getQuestionPostId() != null) {
                QaPost qaPost = getQaPostById(Long.valueOf(post.getQuestionPostId()));
                if ("choice".equals(qaPost.getQuestionType())) {
                    // 如果是选择题，获取所有选项
                    qaPost.setAnswerOptions(getOptionsByQuestionId(qaPost.getId()));
                }
                postshow.setQaPost(qaPost);
            }

            // 如果传入了用户 ID，获取该用户的相关信息（点赞、收藏、关注等）
            if (userId != null) {
                int uid = Math.toIntExact(userId);
                postshow.setLikedByUser(likeMapper.isPostLikedByUser(Long.valueOf(post.getId()), userId));  // 判断该用户是否点赞了该帖子
                postshow.setFavoritedByUser(favoriteService.isPostFavorited(uid, post.getId()) > 0);  // 判断该用户是否收藏了该帖子
                postshow.setFollowedByUser(followService.isUserFollowing(uid, Math.toIntExact(post.getUserid())));  // 判断该用户是否关注了帖子作者
            }

            // 将处理后的帖子信息添加到返回结果列表
            postshows.add(postshow);
        }

        // 返回所有符合条件的帖子
        return postshows;
    }

    /**
     * 更新帖子的审核状态
     * <p>
     * 该方法用于将帖子标记为已审核并更新相关分类中的帖子数量。
     *
     * @param post 要更新状态的帖子
     */
    public void updatePostStatus(Post post) {
        // **1. 更新帖子为已审核状态**
        postMapper.updatePostStatusToApproved(post.getId());  // 根据帖子 ID 更新其审核状态为已通过（已审核）

        // **2. 更新分类中帖子数量**
        int i = postMapper.incrementPostCountInCategory(post.getCategoryId());// 审核通过的帖子所在的分类数量增加 1
        if (i <= 0)  PostS_Util.isTrue(true,ErrorCode.FAILED,"审核通过的帖子数量为0");
    }

    /**
     * 获取当前用户关注的所有用户发布的帖子，并根据可见性进行筛选
     *
     * @param userId 当前用户的 ID
     * @return 返回当前用户关注的所有用户发布的可见帖子列表
     */
    public List<Postshow> getFollowedUsersPosts(int userId) {
        // **1. 获取当前用户关注的所有用户 ID**
        List<Integer> followedUserIds = userService.getFollowedUserIds(userId);
        if (followedUserIds == null || followedUserIds.isEmpty()) {
            return Collections.emptyList();  // 如果没有关注的人，返回空列表
        }

        // **2. 查询当前用户关注的所有用户发布的帖子**
        List<Post> posts = postMapper.getPostsByUserIds(followedUserIds);
        if (posts == null || posts.isEmpty()) {
            return Collections.emptyList();  // 如果没有帖子，返回空列表
        }

        List<Postshow> postshows = new ArrayList<>();

        for (Post post : posts) {
            String visibility = post.getVisibility();
            boolean canView = false;

            // **3. 判断帖子可见性逻辑**
            switch (visibility) {
                case "public":
                    canView = true;  // 公共帖，任何人都可以查看
                    break;
                case "friends":
                    // 如果是“朋友可看”，则检查当前用户是否是帖子的作者的粉丝
                    canView = followService.isUserFollowing(post.getUserid(), userId);  // 作者是否关注当前用户（你是他的粉丝）
                    break;
                case "followed":
                    // 如果是“关注可看”，则检查当前用户是否关注了作者
                    canView = followService.isUserFollowing(userId, post.getUserid());  // 当前用户是否关注作者
                    break;
                case "private":
                    // 如果是“仅我可看”，则只能自己查看自己的帖子
                    canView = userId == post.getUserid();  // 仅本人可看
                    break;
            }

            // 如果没有权限查看，跳过当前帖子
            if (!canView) continue;

            // **4. 将 Post 转换为 Postshow**
            Postshow postshow = new Postshow();
            postshow.setId(post.getId());  // 设置帖子 ID
            postshow.setUsers(userService.getUserByIdPost(post.getUserid()));  // 设置帖子的作者信息
            postshow.setTitle(post.getTitle());  // 设置标题
            postshow.setContent(post.getContent());  // 设置内容
            postshow.setCategoryId(post.getCategoryId());  // 设置类别 ID
            postshow.setVisibility(post.getVisibility());  // 设置可见性
            postshow.setViews(post.getViews());  // 设置浏览量
            postshow.setLikes(post.getLikes());  // 设置点赞数
            postshow.setCreatedAt(post.getCreatedAt());  // 设置创建时间
            postshow.setBanned(post.getBanned());  // 设置是否被封禁
            postshow.setApproved(post.getApproved());  // 设置是否已审核
            postshow.setVideoUrl(post.getVideoUrl());  // 设置视频 URL
            postshow.setCommentPostId(post.getCommentPostId());  // 设置评论帖子的 ID
            postshow.setLocation(post.getLocation());  // 设置位置
            postshow.setQuestionPostId(post.getQuestionPostId());  // 设置问答帖子 ID

            // **获取每个帖子的图片列表**
            List<String> images = postMapper.getImagesByPostId(post.getId());
            postshow.setImages(images);  // 设置图片列表

            // **查询问答帖子并添加**
            if (post.getQuestionPostId() != null) {
                QaPost qaPost = this.getQaPostById(Long.valueOf(post.getQuestionPostId()));  // 获取问答帖子
                if ("choice".equals(qaPost.getQuestionType())) {
                    List<QaAnswerOption> options = this.getOptionsByQuestionId(qaPost.getId());  // 获取选项
                    qaPost.setAnswerOptions(options);  // 设置问答选项
                }
                postshow.setQaPost(qaPost);  // 设置问答帖
            }

            // **点赞、收藏、关注状态**
            postshow.setLikedByUser(this.isPostLikedByUser(post.getId(), userId));  // 判断当前用户是否点赞了该帖子
            postshow.setFavoritedByUser(favoriteService.isPostFavorited(userId, post.getId()) > 0);  // 判断当前用户是否收藏了该帖子

            // **将转换后的 Postshow 添加到列表中**
            postshows.add(postshow);
        }

        return postshows;  // 返回所有符合条件的帖子列表
    }

    /**
     * 判断指定的用户是否点赞了指定的帖子
     *
     * @param postId 帖子的 ID
     * @param userId 用户的 ID
     * @return 如果用户点赞了该帖子，则返回 true；否则返回 false
     */
    public boolean isPostLikedByUser(int postId, int userId) {
        // **查询用户是否点赞了该帖子**
        Integer count = postMapper.countLikesByUserAndPost(userId, postId);

        // **判断是否存在点赞记录并且点赞数大于 0**
        return count != null && count > 0;  // 如果 count 为 null 或者 count 为 0，表示用户没有点赞该帖子，返回 false；否则返回 true
    }

    /**
     * 根据问答帖的 ID 获取对应的问答帖子信息
     *
     * @param questionPostId 问答帖的 ID
     * @return 返回对应的 QaPost 对象，如果没有找到则返回 null
     */
    public QaPost getQaPostById(Long questionPostId) {
        // **调用 qaPostMapper 查询指定 ID 的问答帖子**
        QaPost qaPost = qaPostMapper.selectQaPostById(Math.toIntExact(questionPostId));
        if (qaPost == null) {
            PostS_Util.isTrue(true,ErrorCode.FAILED,"根据问答帖的 ID 获取对应的问答帖子信息失败");
        }
        return qaPost;
    }

    /**
     * 根据问题 ID 查询所有的选项
     *
     * @param questionId 问题帖的 ID
     * @return 返回该问题帖下的所有选项列表，如果没有选项则返回空列表
     */
    public List<QaAnswerOption> getOptionsByQuestionId(int questionId) {
        // **调用 qaAnswerOptionMapper 查询该问题 ID 下的所有选项**
        List<QaAnswerOption> qaAnswerOptions = qaAnswerOptionMapper.selectOptionsByQuestionId(questionId);
        if (qaAnswerOptions == null || qaAnswerOptions.isEmpty()) {
            PostS_Util.isTrue(true,ErrorCode.FAILED,"根据问题 ID 查询所有的选项失败");
        }
        return qaAnswerOptions;
    }

    /**
     * 获取前15条话题或帖子（按时间排序）
     *
     * @return 返回经过处理后的话题或帖子列表，按点赞数降序排序
     */
    public List<PostTopic> getRecentPostsOrTopics() {
        // **1. 从数据库获取最近的帖子或话题列表**
        List<PostTopic> list = postMapper.getRecentPostsOrTopics();

        // **2. 如果列表为空或列表长度小于等于5，返回空列表**
        if (list == null || list.size() <= 5) {
            PostS_Util.isTrue(true,ErrorCode.FAILED,"查询失败");
        }

        // **3. 跳过列表中的第一个元素（假设第一个元素不符合要求）**
        List<PostTopic> skippedFirst = list.subList(1, list.size());

        // **4. 截取到倒数第4个元素之前，即丢弃列表中最后4个元素**
        int endIndex = skippedFirst.size() - 4;
        List<PostTopic> filteredList = new ArrayList<>(skippedFirst.subList(0, endIndex));

        // **5. 按点赞数降序排序**
        filteredList.sort((a, b) -> Integer.compare(b.getLikes(), a.getLikes()));

        // **6. 返回处理后的帖子或话题列表**
        return filteredList;
    }

    /**
     * 更新帖子可见性
     *
     * @param postId 帖子 ID
     * @param visibility 帖子的可见性值
     * @return 返回统一响应结果，表示操作是否成功
     */
    public ResponseResult updatePostVisibility(Long postId, String visibility) {
        // **1. 校验传入的 visibility 是否有效**
        if (!isValidVisibility(visibility)) {
            PostS_Util.isTrue(true,ErrorCode.FAILED,"无效的可见性值");
        }

        // **2. 根据帖子 ID 查询帖子**
        Post post = postMapper.findById(postId);

        // **3. 更新帖子可见性**
        post.setVisibility(visibility);

        // **4. 更新数据库中帖子的可见性字段**
        postMapper.updateVisibility(Long.valueOf(post.getId()), post.getVisibility());

        // **5. 返回成功响应**
        return ResponseResult.success("帖子可见性更新成功", null);
    }

    /**
     * 校验可见性值是否合法
     *
     * @param visibility 可见性值
     * @return 如果可见性值合法，返回 true；否则返回 false
     */
    private boolean isValidVisibility(String visibility) {
        // **1. 校验 visibility 是否为合法的可见性值**
        return "public".equals(visibility)     // 公开
                || "friends".equals(visibility)  // 粉丝可看
                || "followers".equals(visibility) // 关注了的人可以看
                || "private".equals(visibility); // 仅本人可看
    }

    /**
     * 获取用户点赞的所有帖子
     *
     * @param userId 用户 ID
     * @return 用户点赞的帖子列表
     */
    @Override
    public List<Postshow> getLikedPostsByUser(int userId) {
        List<Post> posts = postMapper.getLikedPostsByUser(userId);

        if (posts == null || posts.isEmpty()) {
            return Collections.emptyList();
        }

        List<Postshow> postshows = new ArrayList<>();

        for (Post post : posts) {
            Postshow postshow = new Postshow();
            postshow.setId(post.getId());
            postshow.setUsers(userService.getUserByIdPost(post.getUserid()));
            postshow.setTitle(post.getTitle());
            postshow.setContent(post.getContent());
            postshow.setCategoryId(post.getCategoryId());
            postshow.setVisibility(post.getVisibility());
            postshow.setViews(post.getViews());
            postshow.setLikes(post.getLikes());
            postshow.setCreatedAt(post.getCreatedAt());
            postshow.setBanned(post.getBanned());
            postshow.setApproved(post.getApproved());
            postshow.setVideoUrl(post.getVideoUrl());
            postshow.setCommentPostId(post.getCommentPostId());
            postshow.setLocation(post.getLocation());
            postshow.setQuestionPostId(post.getQuestionPostId());

            // 设置帖子图片
            postshow.setImages(postMapper.getImagesByPostId(post.getId()));

            // 处理问答帖子
            if (post.getQuestionPostId() != null) {
                QaPost qaPost = getQaPostById(Long.valueOf(post.getQuestionPostId()));
                if ("choice".equals(qaPost.getQuestionType())) {
                    qaPost.setAnswerOptions(getOptionsByQuestionId(qaPost.getId()));
                }
                postshow.setQaPost(qaPost);
            }

            // 单独再设置该用户是否点赞（因为是点赞列表可以直接给 true）
            postshow.setLikedByUser(true);

            // 收藏、关注信息
            postshow.setFavoritedByUser(favoriteService.isPostFavorited(userId, post.getId()) > 0);
            postshow.setFollowedByUser(followService.isUserFollowing(userId, Math.toIntExact(post.getUserid())));

            postshows.add(postshow);
        }

        return postshows;
    }
}
